/*
 * Copyright (c) 2023, Meta
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#include "main.h"
#include "ay_fs.hpp"
#include "ay_uart.hpp"
#include <zephyr/drivers/gpio.h>

ay_fs_obj *fs;

void test_task_fn(void *p1, void *p2, void *p3)
{

	// int64_t ms = k_uptime_get();  // 获取系统启动以来的毫秒数
	while (1)
	{
		k_sleep(K_MSEC(10000));
		int64_t ms = k_uptime_get(); // 获取系统启动以来的毫秒数

		cout << "test_task running" << "==" << ms << endl;
	}
}

// K_THREAD_DEFINE(test_task, 1024, test_task_fn, NULL, NULL, NULL, 7, 0, 0);

// static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET(DT_ALIAS(button0), gpios);
static const struct gpio_dt_spec button = GPIO_DT_SPEC_GET(DT_ALIAS(sw0), gpios);
static const struct gpio_dt_spec led = GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios);
static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(DT_ALIAS(led1), gpios);

void gpio_init(void)
{
	int ret;

	if (!gpio_is_ready_dt(&led))
	{
		return;
	}
	if (!gpio_is_ready_dt(&led1))
	{
		return;
	}

	// 配置为输出模式
	ret = gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE);
	if (ret < 0)
	{
		return;
	}

	// 配置为输出模式
	ret = gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE);
	if (ret < 0)
	{
		return;
	}

	//  while (1)
	//  {
	// 	ret = gpio_pin_toggle_dt(&led);
	// 	if (ret < 0)
	// 	{
	// 		return;
	// 	}
	// 	ret = gpio_pin_toggle_dt(&led1);
	// 	if (ret < 0)
	// 	{
	// 		return;
	// 	}
	// 	// led_state = !led_state;
	// 	printf("LED state:\n");
	// 	k_msleep(1000);
	// }

	gpio_pin_set_dt(&led, 1);
	gpio_pin_set_dt(&led1, 1);

	// 在使用gpio外设之前判断是否可用
	if (!gpio_is_ready_dt(&button))
	{
		printk("Error: %s device not ready\n", button.port->name);
		return;
	}
	// 配置为输入模式
	gpio_flags_t in_flags = GPIO_INPUT | GPIO_PULL_UP;
	ret = gpio_pin_configure_dt(&button, in_flags);
	if (ret < 0)
	{
		printk("Error %d: failed to configure %s pin %d\n",
			   ret, button.port->name, button.pin);
		return;
	}
	printk("Set up button at %s pin %d\n", button.port->name, button.pin);
	// 获取按键状态
	// while (1)
	// {
	// 	ret = gpio_pin_get_dt(&button);
	// 	if (ret < 0)
	// 	{
	// 		printk("Error %d: failed to read %s pin %d\n",
	// 			   ret, button.port->name, button.pin);
	// 		return;
	// 	}
	// 	printk("Button state is %d\n", ret);
	// 	k_sleep(K_MSEC(2000));
	// }
	dev.dev_mode = gpio_pin_get_dt(&button);
	printk("按键状态: %d\n", dev.dev_mode);
}

#include <zephyr/drivers/adc.h>

static const struct adc_dt_spec adc_channel = ADC_DT_SPEC_GET(DT_PATH(zephyr_user));

void read_adc_tk(void *p1, void *p2, void *p3)
{
	int err;
	int16_t buf;
	struct adc_sequence sequence = {
		.buffer = &buf,
		.buffer_size = sizeof(buf),
	};

	if (!adc_is_ready_dt(&adc_channel))
	{
		printk("ADC not ready\n");
		return;
	}
	// ENOTSUP
	err = adc_channel_setup_dt(&adc_channel);
	if (err < 0)
	{
		printk("ADC channel setup failed: %d\n", err);
		return;
	}

	err = adc_sequence_init_dt(&adc_channel, &sequence);
	if (err < 0)
	{
		printk("ADC sequence init failed: %d\n", err);
		return;
	}
	while (1)
	{
		err = adc_read(adc_channel.dev, &sequence);
		if (err < 0)
		{
			printk("ADC read failed: %d\n", err);
		}
		else
		{
			// printk("ADC raw value: %d\n", buf);
			dev.dev_battery = buf;
		}
		k_msleep(1000);
	}
}

K_THREAD_DEFINE(read_adc, 2048, read_adc_tk, NULL, NULL, NULL, 7, 0, 0);

void read_dev_mode_tk(void *p1, void *p2, void *p3)
{
	int err;
	k_msleep(8000);
	LOG_INF("开启指示灯任务");

	while (1)
	{
		if (dev.err_code == -1) // 存储初始化失败
		{
			gpio_pin_set_dt(&led1, 1);
			k_msleep(300);
			gpio_pin_set_dt(&led1, 0);
			k_msleep(300);
			gpio_pin_set_dt(&led1, 1);
			k_msleep(300);
			gpio_pin_set_dt(&led1, 0);
			k_msleep(300);
		}
		else if (dev.err_code == -2) // 文件系统挂载失败
		{
			gpio_pin_set_dt(&led1, 1);
			k_msleep(300);
			gpio_pin_set_dt(&led1, 0);
			k_msleep(300);
			gpio_pin_set_dt(&led1, 1);
			k_msleep(300);

			gpio_pin_set_dt(&led1, 0);
			k_msleep(300);

			gpio_pin_set_dt(&led1, 1);
			k_msleep(300);

			gpio_pin_set_dt(&led1, 0);
			k_msleep(300);
		}
		else if (dev.err_code == 0)
		{
			//
		}

		k_msleep(1000);
	}
}
void set_errcode(int num)
{
	dev.err_code = num;

}
K_THREAD_DEFINE(read_dev_mode, 2048, read_dev_mode_tk, NULL, NULL, NULL, 7, 0, 0);
#include "ay_ble.hpp"

int main(void)
{

	for (int i = 0; i < 8; i++)
	{

		printk("启动中...%d\n", 8 - i);
		k_sleep(K_MSEC(1000));
	}

	std::cout << "开机 : " << CONFIG_BOARD << std::endl;
	std::cout << "编译时间 : " << __DATE__ << " " << __TIME__ << std::endl;
	k_sleep(K_MSEC(500));

	// 读取默认GPIO状态
	gpio_init();
	// 模式选择
	if (dev.dev_mode == 0)
	{
		gpio_pin_set_dt(&led1, 1);
		gpio_pin_set_dt(&led, 0);

		std::cout << "当前是离线记录模式" << std::endl;
		fs = new ay_fs_obj();

		dev.current_file_name = "/SD:/" + to_string(dev.dev_count) + "_" + to_string(k_uptime_get()) + ".csv";
	}
	else if (dev.dev_mode == 1)
	{
		std::cout << "当前是蓝牙模式" << std::endl;

		gpio_pin_set_dt(&led1, 0);
		gpio_pin_set_dt(&led, 1);

		ble_init();
	}

	// fs = new ay_fs_obj();

	// dev.current_file_name = "/SD:/" + to_string(dev.dev_count) + "_" + to_string(k_uptime_get()) + ".csv";

	if (dev.err_code == 0)
	{
		rx_uart_init();
	}

	// rx_uart_init();

	//	ble_init();

	return 0;
}
